home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / disk utilities / backup / backup_restore / backup_src_v3.20.lha / GadgetTools.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-08-02  |  19.0 KB  |  867 lines
  1. /* GadgetTools.c */
  2. /* 02 Aug 1996 15:38:06 */
  3.  
  4. #ifndef    BACKUP_INCLUDE
  5. #include "IncludeAll.c"
  6. #endif
  7. #include "Backup.h"
  8. #include "Backup_proto.h"
  9. #include <gadgets/NoteBook.h>
  10. #include <gadgets/FrameGad.h>
  11. #include <gadgets/ALVGadget.h>
  12. #include <gadgets/PcBar.h>
  13. #include "BackupStrings.h"
  14.  
  15.  
  16. /* aus Backup_Window.c */
  17. extern APTR vi;                /* VisualInfo */
  18. extern struct DrawInfo *myDrawInfo;
  19. extern struct Screen *WBScreen;
  20.  
  21.  
  22. static BOOL AddGadgetShort(const char *Text, struct Gadget *Gad, UWORD GadgetType, struct GadgetShort *gShort);
  23. static struct GadgetShortInfo *GetGadgetShortInfo(const char *Text, struct GadgetShort *gShort);
  24.  
  25.  
  26. void ActivateStringGadget(struct Window *Win, struct Requester *Req, struct Gadget **Gad)
  27. {
  28.     ASSERT_VALID(Win);
  29.     ASSERT_VALID0(Req);
  30.     ASSERT_VALID(Gad);
  31.  
  32.     if (*Gad)
  33.         ActivateGadget(*Gad, Win, Req);
  34. }
  35.  
  36.  
  37. void myOnOffGadget(struct Gadget *Gad, struct Window *Win, struct Requester *Req, short On)
  38. {
  39.     UWORD Pos;
  40.  
  41.     ASSERT_VALID0(Win);
  42.     ASSERT_VALID0(Req);
  43.     ASSERT_VALID(Gad);
  44.  
  45.     if (((Gad->Flags & GFLG_DISABLED) && !On) ||
  46.         (!(Gad->Flags & GFLG_DISABLED) && On) )
  47.         return;
  48.  
  49.     if (Win)
  50.         {
  51.         Pos = RemoveGList(Win, Gad, 1);
  52.         if (Pos == ~0)
  53.             return;
  54.         }
  55.     if (On)
  56.         {
  57.         struct RastPort *rp;
  58.  
  59.         Gad->Flags &= ~GFLG_DISABLED;
  60.  
  61.         /* Boolean-Gadgets ohne Images jetzt löschen */
  62.         if (Win && (Gad->GadgetType & GTYP_GTYPEMASK) == GTYP_BOOLGADGET
  63.                 && !(Gad->Flags & GFLG_GADGIMAGE))
  64.             {
  65.             short Left, Top;
  66.  
  67.             Left = GetGadgetLeftEdge(Win, Req, Gad);
  68.             Top = GetGadgetTopEdge(Win, Req, Gad);
  69.  
  70.             rp = Req ? Req->ReqLayer->rp : Win->RPort;
  71.             EraseRect(rp, Left, Top,
  72.                 Left + Gad->Width - 1,
  73.                 Top + Gad->Height - 1);
  74.             }
  75.         }
  76.     else
  77.         Gad->Flags |=  GFLG_DISABLED;
  78.  
  79.     if (Win)
  80.         {
  81.         AddGList(Win, Gad, Pos, 1, Req);
  82.  
  83.         RefreshGList(Gad, Win, Req, 1);    
  84.         }
  85. }
  86.  
  87.  
  88. void SetScroller(struct Window *Win, struct Requester *Req, struct Gadget *Gad,
  89.     short visibleLines, short totalLines, short TopLine, short Overlap)
  90. {
  91.     struct PropInfo *prop;
  92.     unsigned short hidden;
  93.     USHORT VertBody, VertPot; 
  94.  
  95.     ASSERT_VALID(Win);
  96.     ASSERT_VALID0(Req);
  97.     ASSERT_VALID(Gad);
  98.  
  99.     TopLine = max(TopLine, 0);
  100.  
  101.     hidden = max(totalLines - visibleLines, 0);
  102.     if (TopLine > hidden)
  103.         TopLine = hidden;
  104.  
  105.     if (hidden > 0)
  106.         {
  107.         VertBody = (USHORT) (((ULONG) (visibleLines-Overlap) * MAXBODY) /
  108.                 (totalLines - Overlap) );
  109.         VertPot  = (USHORT) (((ULONG) TopLine * MAXPOT) / hidden);
  110.         }
  111.     else
  112.         {
  113.         VertBody = MAXBODY;
  114.         VertPot = 0;
  115.         }
  116.  
  117.     prop = (struct PropInfo *) Gad->SpecialInfo;
  118.     NewModifyProp(Gad, Win, Req, prop->Flags,
  119.         0, VertPot, 0, VertBody, 1 );
  120. }
  121.  
  122.  
  123. short GetScroller(const struct Gadget *Gad, short visibleLines, short totalLines)
  124. {
  125.     struct PropInfo *prop;
  126.     UWORD hidden;
  127.  
  128.     ASSERT_VALID(Gad);
  129.     prop = (struct PropInfo *) Gad->SpecialInfo;
  130.     hidden = max(totalLines - visibleLines, 0);
  131.     return (short) ((((ULONG) hidden * prop->VertPot) + (MAXPOT/2)) / MAXPOT);
  132. }
  133.  
  134.  
  135. short GetGadgetLeftEdge(const struct Window *Win, const struct Requester *Req,
  136.         const struct Gadget *Gad)
  137. {
  138.     short LeftEdge;
  139.  
  140.     ASSERT_VALID0(Win);
  141.     ASSERT_VALID0(Req);
  142.     ASSERT_VALID(Gad);
  143.  
  144.     LeftEdge = Gad->LeftEdge;
  145.     if (Gad->Flags & GFLG_RELRIGHT)
  146.         LeftEdge += (Req ? Req->Width : Win->Width) - 1;
  147.  
  148.     return LeftEdge;
  149. }
  150.  
  151.  
  152. short GetGadgetTopEdge(const struct Window *Win, const struct Requester *Req,
  153.         const struct Gadget *Gad)
  154. {
  155.     short TopEdge;
  156.  
  157.     ASSERT_VALID0(Win);
  158.     ASSERT_VALID0(Req);
  159.     ASSERT_VALID(Gad);
  160.  
  161.     TopEdge = Gad->TopEdge;
  162.     if (Gad->Flags & GFLG_RELBOTTOM)
  163.         TopEdge += (Req ? Req->Height : Win->Height) - 1;
  164.  
  165.     return TopEdge;
  166. }
  167.  
  168.  
  169. short GetGadgetWidth(const struct Window *Win, const struct Requester *Req,
  170.         const struct Gadget *Gad)
  171. {
  172.     short Width;
  173.  
  174.     ASSERT_VALID0(Win);
  175.     ASSERT_VALID0(Req);
  176.     ASSERT_VALID(Gad);
  177.  
  178.     Width = Gad->Width;
  179.     if (Gad->Flags & GFLG_RELWIDTH)
  180.         Width += (Req ? Req->Width : Win->Width);
  181.  
  182.     return Width;
  183. }
  184.  
  185.  
  186. short GetGadgetHeight(const struct Window *Win, const struct Requester *Req,
  187.         const struct Gadget *Gad)
  188. {
  189.     short TopEdge;
  190.  
  191.     ASSERT_VALID0(Win);
  192.     ASSERT_VALID0(Req);
  193.     ASSERT_VALID(Gad);
  194.  
  195.     TopEdge = Gad->Height;
  196.     if (Gad->Flags & GFLG_RELHEIGHT)
  197.         TopEdge += Req ? Req->Height : Win->Height;
  198.  
  199.     return TopEdge;
  200. }
  201.  
  202.  
  203. /* Größe und Position für NewWindow anhand des WorkBench-Screens anpassen. */
  204. void AdjustWindowSize(struct NewWindow *New)
  205. {
  206.     ASSERT_VALID(New);
  207.  
  208.     New->Height = min(New->Height, WBScreen->Height);
  209.     New->Width  = min(New->Width,  WBScreen->Width);
  210.  
  211.     New->TopEdge = min(New->TopEdge, WBScreen->Height - New->Height);
  212.     New->LeftEdge = min(New->LeftEdge, WBScreen->Width - New->Width);
  213. }
  214.  
  215.  
  216. /* Window <InnerWin> innerhalb des Windows <Win> zentrieren 
  217.    Aufruf VOR OpenWindow() !!
  218. */
  219. void CenterWindow(const struct Window *Win, struct NewWindow *InnerWin)
  220. {
  221.     ASSERT_VALID(Win);
  222.     ASSERT_VALID(InnerWin);
  223.  
  224.     InnerWin->LeftEdge = Win->LeftEdge + (Win->Width - InnerWin->Width) / 2;
  225.     InnerWin->TopEdge  = Win->TopEdge  + (Win->Height - InnerWin->Height) / 2;
  226. }
  227.  
  228.  
  229. /* Window <InnerWin> über dem Mauszeiger zentrieren 
  230.    Aufruf VOR OpenWindow() !!
  231. */
  232. void CenterWindowMouse(const struct Window *activeWin, struct NewWindow *InnerWin)
  233. {
  234.     short MouseX, MouseY;
  235.  
  236.     ASSERT_VALID(activeWin);
  237.     ASSERT_VALID(InnerWin);
  238.  
  239.     MouseX = activeWin->WScreen->MouseX;
  240.     MouseY = activeWin->WScreen->MouseY;
  241.  
  242.     InnerWin->LeftEdge = MouseX - InnerWin->Width / 2;
  243.     InnerWin->TopEdge  = MouseY - InnerWin->Height / 2;
  244. }
  245.  
  246.  
  247. /* Border zeichnen */
  248. void myDrawBorder(struct Window *Win, struct Requester *Req,
  249.         short Left, short Top, short Width, short Height, BOOL Recessed)
  250. {
  251.     struct RastPort *rp;
  252.  
  253.     ASSERT_VALID(Win);
  254.     ASSERT_VALID0(Req);
  255.  
  256.     rp = Req ? Req->ReqLayer->rp : Win->RPort;
  257.  
  258.     DrawBevelBox(rp, Left, Top, Width, Height,
  259.         GTBB_FrameType, BBFT_BUTTON,
  260.         Recessed ? GTBB_Recessed : TAG_IGNORE, TRUE,
  261.         GT_VisualInfo, vi,
  262.         TAG_END );
  263. }
  264.  
  265.  
  266. void CheckMenuItem(struct Menu *theMenu, void *MenuId, BOOL Check)
  267. {
  268.     UWORD MenuNum = FindMenuItem(theMenu, MenuId);
  269.     struct MenuItem *Item;
  270.  
  271.     Item = ItemAddress(theMenu, MenuNum);
  272.  
  273.     if (Item)
  274.         {
  275.         if (Check)
  276.             Item->Flags |= CHECKED;
  277.         else
  278.             Item->Flags &= ~CHECKED;
  279.         }
  280. }
  281.  
  282.  
  283. UWORD FindMenuItem(struct Menu *theMenu, void *MenuId)
  284. {
  285.     UWORD MenuNr, ItemNr, SubNr;
  286.     struct MenuItem *Item, *SubItem;
  287.  
  288.     MenuNr = 0;
  289.     while (theMenu)
  290.         {
  291.         if (GTMENU_USERDATA(theMenu) == MenuId)
  292.             return (UWORD) FULLMENUNUM(MenuNr, NOITEM, NOSUB);
  293.  
  294.         ItemNr = 0;
  295.         Item = theMenu->FirstItem;
  296.         while (Item)
  297.             {
  298.             if (GTMENUITEM_USERDATA(Item) == MenuId)
  299.                 return (UWORD) FULLMENUNUM(MenuNr, ItemNr, NOSUB);
  300.  
  301.             SubNr = 0;
  302.             SubItem = Item->SubItem;
  303.             while (SubItem)
  304.                 {
  305.                 if (GTMENUITEM_USERDATA(SubItem) == MenuId)
  306.                     return (UWORD) FULLMENUNUM(MenuNr, ItemNr, SubNr);
  307.  
  308.                 SubItem = SubItem->NextItem;
  309.                 SubNr++;
  310.                 }
  311.             Item = Item->NextItem;
  312.             ItemNr++;
  313.             }
  314.         theMenu = theMenu->NextMenu;
  315.         MenuNr++;
  316.         }
  317.  
  318.     return (UWORD) FULLMENUNUM(NOMENU, NOITEM, NOSUB);
  319. }
  320.  
  321.  
  322. BOOL CreateGadgetShort(struct GadgetShort **gShort)
  323. {
  324.     DestroyGadgetShort(gShort);
  325.  
  326.     *gShort = calloc(sizeof(struct GadgetShort), 1);        // MUSS mit 0 vorbelegt sein!
  327.  
  328.     return (BOOL) (NULL != *gShort);
  329. }
  330.  
  331.  
  332. void DestroyGadgetShort(struct GadgetShort **gShort)
  333. {
  334.     if (*gShort)
  335.         {
  336.         free(*gShort);
  337.         *gShort = NULL;
  338.         }
  339. }
  340.  
  341.  
  342. BOOL EnterGadgetShort(const struct NewGadget *ng, UWORD GadgetType, ULONG *GadgetTags,
  343.         struct Gadget *Gad, struct GadgetShort *gShort)
  344. {
  345.     BOOL Result;
  346.     struct TagItem *Tag;
  347.  
  348.     ASSERT_VALID(ng);
  349.     ASSERT_VALID(gShort);
  350.     ASSERT_VALID(GadgetTags);
  351.  
  352.     if (NULL == Gad)
  353.         return TRUE;
  354.  
  355.     Result = TRUE;
  356.  
  357.     switch (GadgetType)
  358.         {
  359.     case MX_KIND:
  360.         Tag = FindTagItem(GTMX_Labels, (struct TagItem *) GadgetTags);
  361.         if (Tag)
  362.             {
  363.             const char **p;
  364.             short Index = 0;
  365.  
  366.             p = (const char **) Tag->ti_Data;
  367.             while (Result && *p)
  368.                 {
  369.                 Result = AddGadgetShort(*p, Gad, GadgetType, gShort);
  370.                 if (Result)
  371.                     {
  372.                     struct GadgetShortInfo *gInfo;
  373.  
  374.                     gInfo = GetGadgetShortInfo(*p, gShort);
  375.                     if (gInfo)
  376.                         {
  377.                         // in gi_Extra wird der Zählindex des Labels abgelegt!
  378.                         gInfo->gi_Extra = Index;
  379.                         }
  380.                     }
  381.                 p++;
  382.                 Index++;
  383.                 }
  384.             }
  385.         break;
  386.  
  387.     case NOTEBOOK_KIND:
  388.         Tag = FindTagItem(NB_PageList, (struct TagItem *) GadgetTags);
  389.         if (Tag)
  390.             {
  391.             struct NewNBPage *nPage;
  392.             short Index = 0;
  393.  
  394.             nPage = (struct NewNBPage *) Tag->ti_Data;
  395.             while (Result && nPage)
  396.                 {
  397.                 if (NBLT_Text == nPage->nn_LabelType)
  398.                     {
  399.                     Result = AddGadgetShort(nPage->nn_Label, Gad, GadgetType, gShort);
  400.                     if (Result)
  401.                         {
  402.                         struct GadgetShortInfo *gInfo;
  403.  
  404.                         gInfo = GetGadgetShortInfo(nPage->nn_Label, gShort);
  405.                         if (gInfo)
  406.                             {
  407.                             // in gi_Extra wird der Zählindex der Page abgelegt!
  408.                             gInfo->gi_Extra = Index;
  409.                             }
  410.                         }
  411.                     }
  412.                 nPage = nPage->nn_NextPage;
  413.                 Index++;
  414.                 }
  415.             }
  416.         break;
  417.  
  418.     case LISTVIEW_KIND:
  419.         Tag = FindTagItem(GTLV_ShowSelected, (struct TagItem *) GadgetTags);
  420.         if (Tag && 0 != Tag->ti_Data)
  421.             {
  422.             // das verknüpfte String-Gadget eintragen!
  423.             if (ng->ng_GadgetText)
  424.                 Result = AddGadgetShort(ng->ng_GadgetText, (struct Gadget *) Tag->ti_Data, STRING_KIND, gShort);
  425.             }
  426.         else
  427.             {
  428.             if (ng->ng_GadgetText)
  429.                 Result = AddGadgetShort(ng->ng_GadgetText, Gad, GadgetType, gShort);
  430.             }
  431.         break;
  432.  
  433.     case CYCLE_KIND:
  434.         if (ng->ng_GadgetText)
  435.             Result = AddGadgetShort(ng->ng_GadgetText, Gad, GadgetType, gShort);
  436.  
  437.         Tag = FindTagItem(GTCY_Labels, (struct TagItem *) GadgetTags);
  438.         if (Tag && Result)
  439.             {
  440.             struct GadgetShortInfo *gInfo;
  441.  
  442.             gInfo = GetGadgetShortInfo(ng->ng_GadgetText, gShort);
  443.             if (gInfo)
  444.                 {
  445.                 // in gi_Extra wird die Anzahl Labels abgelegt!
  446.                 const char **p;
  447.  
  448.                 p = (const char **) Tag->ti_Data;
  449.                 gInfo->gi_Extra = 0;
  450.                 while (*p)
  451.                     {
  452.                     gInfo->gi_Extra++;
  453.                     p++;
  454.                     }
  455.                 }
  456.             }
  457.         break;
  458.  
  459.     default:
  460.         if (ng->ng_GadgetText)
  461.             Result = AddGadgetShort(ng->ng_GadgetText, Gad, GadgetType, gShort);
  462.         break;
  463.         }
  464.  
  465.     return Result;
  466. }
  467.  
  468.  
  469. static BOOL AddGadgetShort(const char *Text, struct Gadget *Gad, UWORD GadgetType, struct GadgetShort *gShort)
  470. {
  471.     struct GadgetShortInfo *gInfo;
  472.  
  473.     gInfo = GetGadgetShortInfo(Text, gShort);
  474.     if (gInfo)
  475.         {
  476.         if (NULL == gInfo->gi_Gadget)
  477.             {
  478.             gInfo->gi_Gadget = Gad;
  479.             gInfo->gi_GadgetType = GadgetType;
  480.             }
  481.         else
  482.             {
  483.             // Dieses Kürzel wurde schon verwendet!
  484.             return FALSE;
  485.             }
  486.         }
  487.  
  488.     return TRUE;
  489. }
  490.  
  491.  
  492. static struct GadgetShortInfo *GetGadgetShortInfo(const char *Text, struct GadgetShort *gShort)
  493. {
  494.     const unsigned char *p;
  495.  
  496.     p = strchr(Text, '_');
  497.     if (p)
  498.         {
  499.         unsigned char c;
  500.  
  501.         c = ToUpper(p[1]);
  502.         return &gShort->gs_Info[c];
  503.         }
  504.  
  505.     return NULL;
  506. }
  507.  
  508.  
  509. BOOL HandleGadgetShort(const struct GadgetShort *gShort, struct Window *Win,
  510.         USHORT code, struct Hook *GadgetHandlerHook)
  511. {
  512.     BOOL Found = FALSE;
  513.     unsigned char c;
  514.     const struct GadgetShortInfo *GSInfo;
  515.  
  516.     c = ToUpper(code);
  517.     GSInfo = &gShort->gs_Info[c];
  518.  
  519.     if (GSInfo->gi_Gadget && !(GSInfo->gi_Gadget->Flags & GFLG_DISABLED))
  520.         {
  521.         // Tastatur-Kürzel für Gadget bearbeiten
  522.         Found = TRUE;
  523.  
  524.         switch (GSInfo->gi_GadgetType)
  525.             {
  526.         case BUTTON_KIND:
  527.             CallHook(GadgetHandlerHook, (Object *) GSInfo->gi_Gadget, (ULONG) code);
  528.             break;
  529.  
  530.         case STRING_KIND:
  531.             ActivateGadget(GSInfo->gi_Gadget, Win, NULL);
  532.             break;
  533.  
  534.         case CYCLE_KIND:
  535.             if (IntuitionBase->LibNode.lib_Version >= 39)
  536.                 {
  537.                 ULONG Active, MaxActive;
  538.  
  539.                 // V39 !!!
  540.                 GT_GetGadgetAttrs(GSInfo->gi_Gadget, 
  541.                     Win, NULL,
  542.                     GTCY_Active, &Active,
  543.                     TAG_END);
  544.  
  545.                 MaxActive = GSInfo->gi_Extra;
  546.                 Active = (Active + 1) % MaxActive;
  547.  
  548.                 GT_SetGadgetAttrs(GSInfo->gi_Gadget, 
  549.                     Win, NULL,
  550.                     GTCY_Active, Active,
  551.                     TAG_END);
  552.  
  553.                 CallHook(GadgetHandlerHook, (Object *) GSInfo->gi_Gadget, (ULONG) Active);
  554.                 }
  555.             break;
  556.  
  557.         case MX_KIND:
  558.             GT_SetGadgetAttrs(GSInfo->gi_Gadget, 
  559.                 Win, NULL,
  560.                 GTMX_Active, GSInfo->gi_Extra,
  561.                 TAG_END);
  562.  
  563.             CallHook(GadgetHandlerHook, (Object *) GSInfo->gi_Gadget, (ULONG) GSInfo->gi_Extra);
  564.             break;
  565.  
  566.         case CHECKBOX_KIND:
  567.             GT_SetGadgetAttrs(GSInfo->gi_Gadget,
  568.                 Win, NULL,
  569.                 GTCB_Checked, !(GSInfo->gi_Gadget->Flags & GFLG_SELECTED),
  570.                 TAG_END);
  571.  
  572.             CallHook(GadgetHandlerHook, (Object *) GSInfo->gi_Gadget, (ULONG) (GSInfo->gi_Gadget->Flags & GFLG_SELECTED));
  573.             break;
  574.  
  575.         case NOTEBOOK_KIND:
  576.             SetGadgetAttrs(GSInfo->gi_Gadget, 
  577.                 Win, NULL,
  578.                 NB_ActivePage, GSInfo->gi_Extra,
  579.                 TAG_END);
  580.             CallHook(GadgetHandlerHook, (Object *) GSInfo->gi_Gadget, (ULONG) GSInfo->gi_Extra);
  581.             break;
  582.             }
  583.         }
  584.  
  585.     return Found;
  586. }
  587.  
  588.  
  589. struct Gadget *CreateGadgetList(struct Gadget **GadgetListPtr, short NumGad,
  590.         struct TextAttr *GadgetFontAttr,
  591.         UWORD *GadgetTypes, struct NewGadget *NGad, 
  592.         struct Gadget **GadgetList, ULONG *GadgetTags,
  593.         struct GadgetShort *gShort, struct MinList *ResourceList,
  594.         ULONG ScaleX, ULONG ScaleY, UWORD OffsetX, UWORD OffsetY)
  595. {
  596.     struct Gadget *gad;
  597.     short n;
  598.  
  599.     gad = CreateContext(GadgetListPtr);
  600.  
  601.     for (n=0; gad && n<NumGad ; n++ )
  602.         {
  603.         struct NewGadget ng;
  604.  
  605.         ng = NGad[n];
  606.  
  607.         if (NULL == ng.ng_TextAttr)
  608.             ng.ng_TextAttr = GadgetFontAttr;
  609.         ng.ng_VisualInfo = vi;
  610.         ng.ng_LeftEdge = ng.ng_LeftEdge * ScaleX/65535;
  611.         ng.ng_TopEdge = ng.ng_TopEdge * ScaleY/65535;
  612.  
  613.         if (GENERIC_KIND != GadgetTypes[n])
  614.             {
  615.             // Gadgets GENERIC_KIND werden nicht skaliert!
  616.             ng.ng_Width = ng.ng_Width * ScaleX/65535;
  617.             ng.ng_Height = ng.ng_Height * ScaleY/65535;
  618.             }
  619.  
  620.         if (GENERIC_KIND != GadgetTypes[n] && IMAGEBUTTON_KIND != GadgetTypes[n])
  621.             {
  622.             if (ng.ng_GadgetText)
  623.                 ng.ng_GadgetText = (STRPTR) GetString((long) ng.ng_GadgetText);
  624.             }
  625.  
  626.         ng.ng_LeftEdge += OffsetX;
  627.         ng.ng_TopEdge += OffsetY;
  628.  
  629.         switch (GadgetTypes[n])
  630.             {
  631.         case PCBAR_KIND:
  632.             GadgetList[n] = gad = CreatePcBar(&ng,
  633.                         GA_Previous, gad,
  634.                         PB_TextFont, GadgetFontAttr,
  635.                         TAG_MORE, GadgetTags,
  636.                         TAG_END);
  637.             if (gad)
  638.                 RememberBResource(BRES_PCBARGADGET, gad, ResourceList);
  639.             break;
  640.  
  641.         case NOTEBOOK_KIND:
  642.             GadgetList[n] = gad = 
  643.                     CreateNoteBook(&ng,
  644.                         GA_Previous, gad,
  645.                         NB_TabFont, GadgetFontAttr,
  646.                         TAG_MORE, GadgetTags,
  647.                         TAG_END);
  648.             if (gShort)
  649.                 {
  650.                 EnterGadgetShort(&ng, GadgetTypes[n], GadgetTags, gad, gShort);
  651.                 }
  652.             break;
  653.  
  654.         case FRAMEGAD_KIND:
  655.             GadgetList[n] = gad = 
  656.                     CreateFrameGad(&ng,
  657.                         GA_Previous, gad,
  658.                         TAG_MORE, GadgetTags,
  659.                         TAG_END);
  660.             if (gad)
  661.                 RememberBResource(BRES_FRAMEGADGET, gad, ResourceList);
  662.             break;
  663.  
  664.         case ALVGAD_KIND:
  665.             GadgetList[n] = gad = 
  666.                     CreateALVGad(&ng,
  667.                         GA_Previous, gad,
  668.                         TAG_MORE, GadgetTags,
  669.                         TAG_END);
  670.             if (gad)
  671.                 RememberBResource(BRES_ALVGADGET, gad, ResourceList);
  672.             break;
  673.  
  674.         case IMAGEBUTTON_KIND:
  675.             {
  676.             struct GenericGadgetImages *gImg = (struct GenericGadgetImages *) ng.ng_GadgetText;
  677.             struct Image *RenderImage, *SelectedImage;
  678.  
  679.             // Skalierte Images erzeugen
  680.             RenderImage = ScaleImage(gImg->gi_Render, ng.ng_Width, ng.ng_Height);
  681.             if (RenderImage)
  682.                 RememberBResource(BRES_SCALEDIMAGE, RenderImage, ResourceList);
  683.  
  684.             SelectedImage = ScaleImage(gImg->gi_Selected, ng.ng_Width, ng.ng_Height);
  685.             if (SelectedImage)
  686.                 RememberBResource(BRES_SCALEDIMAGE, SelectedImage, ResourceList);
  687.  
  688.             ng.ng_GadgetText = NULL;
  689.  
  690.             if (RenderImage && SelectedImage)
  691.                 {
  692.                 GadgetList[n] = gad = CreateGadgetA(GENERIC_KIND, gad, &ng, (struct TagItem *) GadgetTags);
  693.                 if (gad)
  694.                     {
  695.                     gad->GadgetType |= GTYP_BOOLGADGET;
  696.                     gad->Activation = GACT_RELVERIFY;
  697.                     if (gImg)
  698.                         {
  699.                         gad->Flags |= GFLG_GADGHIMAGE | GFLG_GADGIMAGE;
  700.                         gad->GadgetRender = RenderImage;
  701.                         gad->SelectRender = SelectedImage;
  702.                         }
  703.                     }
  704.                 }
  705.             else
  706.                 {
  707.                 // ScaleImage hat NULL geliefert
  708.                 GadgetList[n] = gad = NULL;
  709.                 }
  710.             }
  711.             break;
  712.  
  713.         case GENERIC_KIND:
  714.             {
  715.             struct GenericGadgetImages *gImg = (struct GenericGadgetImages *) ng.ng_GadgetText;
  716.  
  717.             ng.ng_GadgetText = NULL;
  718.             if (gImg)
  719.                 {
  720.                 // Breite + Höhe des Gadgets von den Images übernehmen
  721.                 ng.ng_Width = gImg->gi_Render->Width;
  722.                 ng.ng_Height = gImg->gi_Render->Height;
  723.                 }
  724.             GadgetList[n] = gad = CreateGadgetA(GadgetTypes[n], gad, &ng, (struct TagItem *) GadgetTags);
  725.             if (gad)
  726.                 {
  727.                 gad->GadgetType |= GTYP_BOOLGADGET;
  728.                 gad->Activation = GACT_RELVERIFY;
  729.                 if (gImg)
  730.                     {
  731.                     gad->Flags |= GFLG_GADGHIMAGE | GFLG_GADGIMAGE;
  732.                     gad->GadgetRender = gImg->gi_Render;
  733.                     gad->SelectRender = gImg->gi_Selected;
  734.                     }
  735.                 }
  736.             }
  737.             break;
  738.  
  739.         case LISTVIEW_KIND:
  740.             if (n > 0)
  741.                 {
  742.                 // GTLV_ShowSelected, <StringGadget> nachtragen
  743.                 struct TagItem *Tag;
  744.  
  745.                 Tag = FindTagItem(GTLV_ShowSelected, (struct TagItem *) GadgetTags);
  746.                 if (Tag && 0 != Tag->ti_Data && STRING_KIND == GadgetTypes[n-1])
  747.                     Tag->ti_Data = (ULONG) GadgetList[n-1];
  748.  
  749.                 }
  750.             GadgetList[n] = gad = CreateGadgetA(GadgetTypes[n], gad, &ng, (struct TagItem *) GadgetTags);
  751.             if (gShort)
  752.                 {
  753.                 EnterGadgetShort(&ng, GadgetTypes[n], GadgetTags, gad, gShort);
  754.                 }
  755.             break;
  756.  
  757.         case STRING_KIND:
  758.             ng.ng_Height = ng.ng_TextAttr->ta_YSize + 6;
  759.             GadgetList[n] = gad = CreateGadgetA(GadgetTypes[n], gad, &ng, (struct TagItem *) GadgetTags);
  760.             if (gShort)
  761.                 {
  762.                 EnterGadgetShort(&ng, GadgetTypes[n], GadgetTags, gad, gShort);
  763.                 }
  764.             break;
  765.  
  766.         default:
  767.             GadgetList[n] = gad = CreateGadgetA(GadgetTypes[n], gad, &ng, (struct TagItem *) GadgetTags);
  768.             if (gShort)
  769.                 {
  770.                 EnterGadgetShort(&ng, GadgetTypes[n], GadgetTags, gad, gShort);
  771.                 }
  772.             break;
  773.             }
  774.  
  775.         while (TAG_END != *GadgetTags)
  776.             GadgetTags += 2;
  777.         GadgetTags++;        // TAG_END überlesen
  778.         }
  779.  
  780.     return gad;
  781. }
  782.  
  783.  
  784. void CalcGadgetScale(const struct Screen *GadgetScreen, const struct TextFont *GadgetFont,
  785.         ULONG *ScaleX, ULONG *ScaleY,
  786.         UWORD *OffsetX, UWORD *OffsetY,
  787.         short DesignFontWidth, short DesignFontHeight)
  788. {
  789.     *OffsetX = GadgetScreen->WBorLeft;
  790.     *OffsetY = GadgetScreen->WBorTop + GadgetScreen->RastPort.Font->tf_YSize + 1;
  791.  
  792.     *ScaleX = (65535 * GadgetFont->tf_XSize) / DesignFontWidth;
  793.     if (*ScaleX < 65535)
  794.         *ScaleX = max(65535, 120 * *ScaleX / 100);    // bei kleinen Schriften Window etwas breiter lassen
  795.  
  796.     *ScaleY = (65535 * GadgetFont->tf_YSize) / DesignFontHeight;
  797.     if (*ScaleY < 65535)
  798.         *ScaleY = min(65535, 120 * *ScaleY / 100);    // bei kleinen Schriften Window etwas höher lassen
  799. }
  800.  
  801.  
  802. void SetGadgetPosition(struct Gadget *Gad, short LeftEdge, short TopEdge)
  803. {
  804.     Gad->LeftEdge = LeftEdge;
  805.     Gad->TopEdge = TopEdge;
  806.  
  807.     if (Gad->Flags & GFLG_EXTENDED)
  808.         {
  809.         struct ExtGadget *eGad;
  810.  
  811.         eGad = (struct ExtGadget *) Gad;
  812.         eGad->BoundsLeftEdge = LeftEdge;
  813.         eGad->BoundsTopEdge = TopEdge;
  814.         }
  815. }
  816.  
  817.  
  818. BOOL RememberBResource(enum BResourceType Type, APTR BRes, struct MinList *ResourceList)
  819. {
  820.     struct BResource *ResRemember;
  821.     BOOL Result = FALSE;
  822.  
  823.     ResRemember = malloc(sizeof(struct BResource));
  824.     if (ResRemember)
  825.         {
  826.         ResRemember->br_Node.ln_Type = NT_USER;
  827.         ResRemember->br_Node.ln_Pri = 0;
  828.         ResRemember->br_Node.ln_Name = NULL;
  829.         ResRemember->br_Type = Type;
  830.         ResRemember->br_Resource = BRes;
  831.  
  832.         AddTail((struct List *) ResourceList, &ResRemember->br_Node);
  833.         }
  834.  
  835.     return Result;
  836. }
  837.  
  838.  
  839. void FreeBResources(struct MinList *ResourceList)
  840. {
  841.     struct BResource *BRes;
  842.  
  843.     do    {
  844.         BRes = (struct BResource *) RemHead((struct List *) ResourceList);
  845.         if (BRes)
  846.             {
  847.             switch (BRes->br_Type)
  848.                 {
  849.             case BRES_SCALEDIMAGE:
  850.                 DiscardScaledImage((struct Image *) BRes->br_Resource);
  851.                 break;
  852.             case BRES_ALVGADGET:
  853.                 DestroyALVGad((struct Gadget *) BRes->br_Resource);
  854.                 break;
  855.             case BRES_FRAMEGADGET:
  856.                 DestroyFrameGad((struct Gadget *) BRes->br_Resource);
  857.                 break;
  858.             case BRES_PCBARGADGET:
  859.                 RemovePcBar((struct Gadget *) BRes->br_Resource);
  860.                 break;
  861.                 }
  862.  
  863.             free(BRes);
  864.             }
  865.         } while (BRes);
  866. }
  867.